package pl.smath.expression;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;

public abstract class MultiTerm extends Term{

	private Vector<Term>	terms = new Vector<Term>();
	
	/**
	 * constructor
	 * @param text
	 */
	public MultiTerm(String text) {
		super(text);
	}

	/**
	 * Dodanie podwyrazenia
	 * @param c
	 */
	public void addTerm(Term term){
		
		terms.add(term);
	}
	
	/**
	 * Dodanie podwyrazen
	 * @param c
	 */
	public void addTerms(List<Term> c){
		
		terms.addAll(c);
	}

	
	/**
	 * Pobranie listy podwyrazen
	 * @return
	 */
	public Iterator<Term> getTerms(){
		return terms.iterator();
	}

	/**
	 * Pobranie listy podwyrazen w postaci kopii tablicy.
	 * Same wyrazenia nie sa kopiowane ale tablica tak
	 * @return
	 */
	public List<Term> getTermsList(){
		Vector<Term>	copy = new Vector<Term>();
		Iterator<Term>	it = terms.iterator();
		
		while(it.hasNext()){
			copy.add(it.next());
		}
		
		return copy;
	}
	
	/**
	 * Sprawdzenie czy 2 wyrazenia sa sobie równowazne.
	 * Czyli czy mozna postawic miedzy nimi znak = (w sensie matematycznym)
	 * Np. ponizesze wyrazenia sa rownowazne
	 * c*(a+b) i (b+a)*c
	 */
	public boolean isTheSame(Term term){
		Vector<Term>	tempList = new Vector<Term>();
		
		if(!(term instanceof MultiTerm))
			return false;

		List<Term>	compareTerms = ((MultiTerm)term).getTermsList();
		if(terms.size() != compareTerms.size())
			return false;
		
		// skopiowanie do tablicy tymczasowej podwyrazeń, tak by te znalezione mozna było usuwać
		tempList.addAll(terms);
		
		for(int i = 0; i < compareTerms.size(); i++){
			Term srcTerm = compareTerms.get(i);
			
			boolean found = false;
			for(int j = 0; j < tempList.size(); j++){
				if(srcTerm.isTheSame(tempList.get(j))){
					tempList.remove(j);
					found = true;
					break;
				}
			}
			
			// Nie został znaleziony podobny element. Nie ma sensu porównywac dalej
			if(!found)
				break;
		}
		
		return tempList.isEmpty();
	}
	
}
